home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Games / xjewel / game.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-27  |  10.5 KB  |  431 lines
  1. /*
  2. **
  3. **    X11 Jewel By David Cooper and Jose Guterman 05/92
  4. **
  5. */
  6.  
  7. #include <stdlib.h>
  8.  
  9. #ifdef VMS
  10. #include <decw$include/Xlib.h>
  11. #include <decw$include/Xutil.h>
  12. #include <decw$include/Xos.h>
  13. #else
  14. #include <X11/Xlib.h>
  15. #include <X11/Xutil.h>
  16. #include <X11/Xos.h>
  17. #endif
  18.  
  19. #include "general.h"
  20. #include "logic.h"
  21. #include "hscore.h"
  22. #include "xhscore.h"
  23. #include "jewel.h"
  24. #include "game.h"
  25. #include "panel.h"
  26. #include "xw.h"
  27.  
  28.  
  29. /* util functions */
  30. void Key_Bell()
  31.     {
  32.     if (Sound())
  33.         { XBell(xw_display,100); }
  34.     }
  35. #define STRBUFSIZE 128
  36.  
  37.  
  38. #define RANDY(range) (random()%(range))
  39.  
  40. void Melt_Down()
  41.     {
  42.     int cycle;
  43.     int offx,offy;
  44.     int srcx,srcy, destx,desty;
  45.     unsigned int width,height;
  46.     unsigned int GWIDTH=NUM_COLS*SIZE_PIECE, GHEIGHT=NUM_ROWS*SIZE_PIECE;
  47.  
  48.     struct timeval curtime;
  49.     gettimeofday(&curtime,NULL);
  50.     srandom((unsigned int)(curtime.tv_usec>>8));
  51.  
  52. #define NUM_CYCLES 12
  53.     for(cycle=0;cycle<NUM_CYCLES;cycle++)
  54.       for(srcy=1+cycle ;srcy<(GHEIGHT-10);srcy+=(SIZE_PIECE/2))
  55.         {
  56.         int count;
  57.         for (count=0;count<((NUM_COLS*SIZE_PIECE)/40);count++)
  58.             {
  59.             offx=RANDY(5)-2;
  60.             offy=RANDY(4)+1;
  61.  
  62.             width=RANDY(GWIDTH/2);
  63.             height=RANDY(GHEIGHT-srcy-offy);
  64.  
  65.             /* MAXwidth+MAXoffx must be << GWIDTH */
  66.             srcx=RANDY(GWIDTH-width-(abs(offx)));
  67.             if (offx<0) { srcx-=offx; }
  68.  
  69.             destx=srcx+offx;
  70.             desty=srcy+offy;
  71.             if (desty>(GHEIGHT-1)) break;
  72.  
  73.             XCopyArea(xw_display,xw_window,xw_window,xw_gc,
  74.                 srcx+(BRD_LOC_X+SIZE_PIECE), srcy+BRD_LOC_Y,
  75.                 width,height,
  76.                 destx+(BRD_LOC_X+SIZE_PIECE),desty+BRD_LOC_Y);
  77.             }
  78.         }
  79.     xw_sync_sleep(150L);
  80.  
  81.     /* erase area */
  82. #    define NUM_SCAT 10 /* SIZE_PIECE should be an integral mult of this */
  83.     offx=RANDY(NUM_SCAT);
  84.     offy=RANDY(NUM_SCAT);
  85.     for (srcx=0; srcx < NUM_SCAT; srcx++)
  86.         {
  87.         static int xscat[NUM_SCAT]={ 1, 9, 3, 6, 2, 4, 0, 7, 5, 8 };
  88.         static int yscat[NUM_SCAT]={ 2, 1, 0, 8, 6, 4, 9, 3, 7, 5 };
  89.         for (srcy=0; srcy < NUM_SCAT; srcy++)
  90.             {
  91.             for (destx=0;destx<NUM_COLS;destx++)
  92.               for (desty=0;desty<NUM_ROWS;desty++)
  93.                 {
  94.                 /*XClearArea(xw_display,xw_window,*/
  95.                 XFillRectangle(xw_display,xw_window,PiecesGC[FLASH1],
  96.                     ((destx+1)*SIZE_PIECE)+BRD_LOC_X+
  97.                         xscat[(srcx+srcy+offx)%NUM_SCAT]*(SIZE_PIECE/NUM_SCAT),
  98.                     ((desty)*SIZE_PIECE)+BRD_LOC_Y+
  99.                         yscat[(srcy+offy)%NUM_SCAT]*(SIZE_PIECE/NUM_SCAT),
  100.                     (SIZE_PIECE/NUM_SCAT), (SIZE_PIECE/NUM_SCAT)/*,False*/);
  101.                 }
  102.             }
  103.         }
  104.     xw_sync_sleep(150L);
  105.     }
  106.  
  107.  
  108. void Draw_Piece(piece,x,y)
  109. int piece, x, y;
  110.     {
  111.     /* draw piece at loc x,y */
  112.     /* locations here are not raw board, but the active board */
  113.     if (x<0)
  114.         {
  115.         XCopyPlane(xw_display, PiecesPM[piece], xw_window, PiecesGC[piece],
  116.             0, 0, SIZE_PIECE, SIZE_PIECE,
  117.             PREV_LOC_X+(SIZE_PIECE*1), PREV_LOC_Y+(SIZE_PIECE*(y+1)), 1L);
  118.         }
  119.     else
  120.         {
  121.         XCopyPlane(xw_display, PiecesPM[piece], xw_window, PiecesGC[piece],
  122.             0, 0, SIZE_PIECE, SIZE_PIECE,
  123.             BRD_LOC_X+(SIZE_PIECE*(x+1)), BRD_LOC_Y+(SIZE_PIECE*y), 1L);
  124.         }
  125.     }
  126.  
  127.  
  128. void Flash_Pieces(p_remove, numflash, background)
  129. struct rem_piece p_remove[];
  130. int numflash,background;
  131.     {
  132. #ifndef SLOW_DRAW
  133. #  define SLOW_DRAW 0
  134. #endif
  135.     int reps;
  136.     int findex;
  137.  
  138.     for (reps=0;reps<NUM_FLASH;reps++)
  139.         {
  140.         for (findex=0;findex < numflash;findex++)
  141.             {
  142.             Draw_Piece(FLASH1+reps, p_remove[findex].x, p_remove[findex].y);
  143.             }
  144.         xw_sync_sleep(70L+SLOW_DRAW);
  145.         for (findex=0;findex < numflash;findex++)
  146.             {
  147.             Draw_Piece(p_remove[findex].piece,
  148.                 p_remove[findex].x, p_remove[findex].y);
  149.             }
  150.         xw_sync_sleep(160L+SLOW_DRAW);
  151.         }
  152.     for (findex=0;findex < numflash;findex++)
  153.         {
  154.         Draw_Piece(background, p_remove[findex].x, p_remove[findex].y);
  155.         }
  156.     xw_sync_sleep(100L+SLOW_DRAW);
  157.     }
  158.  
  159. void Redraw_Add_Score(pts,mult)
  160. int pts, mult;
  161.     {
  162. #ifndef SLOW_FONTS
  163. #   define SLOW_FONTS 0
  164. #endif
  165.     char buf[80];
  166.     int y=SCORE_LOC_Y;
  167.     XCharStruct Sizes;
  168.     int dir, asc, dsc;
  169.     /* write points */
  170.     sprintf(buf,"POINTS");
  171.     XDrawImageString(xw_display, xw_window, ScoreGC, SCORE_LOC_X, y,
  172.         buf, strlen(buf));
  173.     sprintf(buf,"%d",pts);
  174.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  175.     XDrawImageString(xw_display, xw_window, ScoreGC,
  176.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  177.     y+=Score_Char_MHeight;
  178.  
  179.     /* write multiple */
  180.     sprintf(buf,"X");
  181.     XDrawImageString(xw_display, xw_window, ScoreGC, SCORE_LOC_X, y,
  182.         buf, strlen(buf));
  183.     sprintf(buf,"%d",mult);
  184.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  185.     XDrawImageString(xw_display, xw_window, ScoreGC,
  186.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  187.     y+=Score_Char_MHeight;
  188.  
  189.     /* wait a while */
  190.     xw_sync_sleep(160L+SLOW_FONTS);
  191.     
  192.     /* put total points up */
  193.     y=SCORE_LOC_Y;
  194.     sprintf(buf,"%6d",(pts * mult));
  195.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  196.     XDrawImageString(xw_display, xw_window, ScoreGC,
  197.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  198.  
  199.     for (y=SCORE_LOC_Y+1; y<(SCORE_LOC_Y + (Score_Char_MHeight*2)) ; y++)
  200.             /* location of SCORE */
  201.         {
  202.         char *buf2="POINTS ";
  203.         XDrawImageString(xw_display, xw_window, ScoreGC, SCORE_LOC_X, y,
  204.             buf2, strlen(buf2));
  205.         XDrawImageString(xw_display, xw_window, ScoreGC,
  206.             (Score_x_right - Sizes.width), y, buf, strlen(buf));
  207.         if (SLOW_FONTS > 0)
  208.             {
  209.             xw_sync_sleep(10L+SLOW_FONTS);
  210.             /* IF THE X-SERVER IS FAST WITH FONTS */
  211.             }
  212.         }
  213.     xw_sync_sleep(110L+SLOW_FONTS);
  214.     }
  215.  
  216.  
  217. void Redraw_Score(Score)
  218. int Score;
  219.     {
  220.     char buf[80];
  221.     XCharStruct Sizes;
  222.     int dir, asc, dsc;
  223.     int y=SCORE_LOC_Y + (Score_Char_MHeight*2);
  224.     /* write Score */
  225.     sprintf(buf,"SCORE  ");
  226.     XDrawImageString(xw_display, xw_window, ScoreGC, SCORE_LOC_X, y,
  227.         buf, strlen(buf));
  228.     sprintf(buf,"%d",Score);
  229.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  230.     XDrawImageString(xw_display, xw_window, ScoreGC,
  231.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  232.     y+=Score_Char_MHeight;
  233.     }
  234.  
  235. void Redraw_Lives(Lives)
  236. int Lives;
  237.     {
  238.     char buf[80];
  239.     XCharStruct Sizes;
  240.     int dir, asc, dsc;
  241.     int y=SCORE_LOC_Y + (Score_Char_MHeight*3);
  242.     /* write Lives */
  243.     sprintf(buf,"LIVES  ");
  244.     XDrawImageString(xw_display, xw_window, ScoreGC, SCORE_LOC_X, y,
  245.         buf, strlen(buf));
  246.     sprintf(buf,"%d",Lives);
  247.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  248.     XDrawImageString(xw_display, xw_window, ScoreGC,
  249.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  250.     y+=Score_Char_MHeight;
  251.     }
  252.  
  253. void Redraw_Speed(Speed)
  254. float Speed;
  255.     {
  256.     char buf[80];
  257.     XCharStruct Sizes;
  258.     int dir, asc, dsc;
  259.     int y=SCORE_LOC_Y + (Score_Char_MHeight*4);
  260.     /* write Speed */
  261.     sprintf(buf,"SPEED  ");
  262.     XDrawImageString(xw_display, xw_window, ScoreGC, SCORE_LOC_X, y,
  263.         buf, strlen(buf));
  264.     sprintf(buf,"%.5f",Speed);
  265.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  266.     XDrawImageString(xw_display, xw_window, ScoreGC,
  267.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  268.     y+=Score_Char_MHeight;
  269.     }
  270.  
  271.  
  272. void Redraw_Stage(Stage)
  273. int Stage;
  274.     {
  275.     char buf[80];
  276.     XCharStruct Sizes;
  277.     int dir, asc, dsc;
  278.     int y=SCORE_LOC_Y + (Score_Char_MHeight*5);
  279.     /* write Stage */
  280.     sprintf(buf,"STAGE  ");
  281.     XDrawImageString(xw_display, xw_window, ScoreGC, SCORE_LOC_X, y,
  282.         buf, strlen(buf));
  283.     sprintf(buf," %d",Stage);
  284.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  285.     XDrawImageString(xw_display, xw_window, ScoreGC,
  286.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  287.     y+=Score_Char_MHeight;
  288.     }
  289.  
  290.  
  291. void Redraw_Rest(Rest)
  292. int Rest;
  293.     {
  294.     char buf[80];
  295.     XCharStruct Sizes;
  296.     int dir, asc, dsc;
  297.     int y=SCORE_LOC_Y + (Score_Char_MHeight*6);
  298.     /* write Rest */
  299.     sprintf(buf,"REST  ");
  300.     XDrawImageString(xw_display, xw_window, ScoreGC, SCORE_LOC_X, y,
  301.         buf, strlen(buf));
  302.     sprintf(buf,"  %d",Rest);
  303.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  304.     XDrawImageString(xw_display, xw_window, ScoreGC,
  305.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  306.     y+=Score_Char_MHeight;
  307.     }
  308.  
  309. void Redraw_Sound()
  310.     {
  311.     char buf[80];
  312.     XCharStruct Sizes;
  313.     int dir, asc, dsc;
  314.     int y=SCORE_LOC_Y + (Score_Char_MHeight*7);
  315.     /* write Sound */
  316.     sprintf(buf,"SOUND ");
  317.     XDrawImageString(xw_display, xw_window, ScoreGC, SCORE_LOC_X, y,
  318.         buf, strlen(buf));
  319.     sprintf(buf,"%s",((Sound()) ? "  ON" : "OFF"));
  320.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  321.     XDrawImageString(xw_display, xw_window, ScoreGC,
  322.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  323.     y+=Score_Char_MHeight;
  324.     }
  325.  
  326. void Redraw_Pause()
  327.     {
  328.     char buf[80];
  329.     XCharStruct Sizes;
  330.     int dir, asc, dsc;
  331.     int y=SCORE_LOC_Y + (Score_Char_MHeight*8);
  332.     /* write Pause */
  333.     if (Paused())
  334.         { sprintf(buf,"PAUSED"); }
  335.     else
  336.         { sprintf(buf,"            "); }
  337.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  338.     XDrawImageString(xw_display, xw_window, ScoreGC,
  339.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  340.     }
  341.  
  342. void Redraw_Game_Board()
  343.     {
  344.     int x,y;
  345.     /* build border */
  346.     for (y=0;y<BOARD_HEIGHT;y++)
  347.         {
  348.         XCopyPlane(xw_display, BorderPM, xw_window, BorderGC, 0, 0,
  349.             Border_Width, Border_Height,
  350.             BRD_LOC_X, BRD_LOC_Y+(SIZE_PIECE*y),1L);
  351.         XCopyPlane(xw_display, BorderPM, xw_window, BorderGC, 0, 0,
  352.             Border_Width, Border_Height,
  353.             BRD_LOC_X+(SIZE_PIECE*(BOARD_WIDTH-1)), BRD_LOC_Y+(SIZE_PIECE*y),1L);
  354.         }
  355.     for (x=1;x<(BOARD_WIDTH-1);x++)
  356.         {
  357.         XCopyPlane(xw_display, BorderPM, xw_window, BorderGC, 0, 0,
  358.             Border_Width, Border_Height,
  359.             BRD_LOC_X+(SIZE_PIECE*x),BRD_LOC_Y+(SIZE_PIECE*(BOARD_HEIGHT-1)),1L);
  360.         }
  361.     for (x=0;x<(PREVIEW_WIDTH);x++)
  362.       for (y=0;y<(PREVIEW_HEIGHT);y++)
  363.         {
  364.         XCopyPlane(xw_display, BorderPM, xw_window, BorderGC, 0, 0,
  365.             Border_Width, Border_Height,
  366.             PREV_LOC_X+(SIZE_PIECE*x),PREV_LOC_Y+(SIZE_PIECE*y),1L);
  367.         }
  368.     /* put pieces on it */
  369.     Redraw_Board();
  370.     }
  371.  
  372. void Start_New_Game()
  373.     {
  374.     extern void Expose_Game();
  375.     XClearWindow(xw_display,xw_window);
  376.     xw_set_timer(Get_Speed_ms());
  377.     JewelState=GAME;
  378.     New_Game();
  379.     Init_Logic();
  380.     Expose_Game();
  381.     }
  382.  
  383. void End_Game()
  384.     {
  385.     char *buf;
  386.     XCharStruct Sizes;
  387.     int dir, asc, dsc;
  388.     int y=SCORE_LOC_Y + (Score_Char_MHeight*8);
  389.  
  390.     buf="GAME OVER";
  391.     XTextExtents(ScoreFont,buf,strlen(buf),&dir,&asc,&dsc,&Sizes);
  392.     XDrawImageString(xw_display, xw_window, ScoreGC,
  393.         (Score_x_right - Sizes.width), y, buf, strlen(buf));
  394.  
  395.     xw_sync_sleep(500L);
  396.     Set_State_High_Score();
  397.     Update_High_Scores(Get_Stage(), Get_Score());
  398.     }
  399.  
  400.  
  401. void Expose_Game()
  402.     {
  403.     XCopyPlane(xw_display, Logo2PM, xw_window, Logo2GC, 0, 0,
  404.         Jewellogo2_Width, Jewellogo2_Height,
  405.         LOGO_LOC_X, LOGO_LOC_Y, 1L);
  406.  
  407.     XSetClipOrigin(xw_display, LogoGC, LOGO_LOC_X, LOGO_LOC_Y );
  408.     XCopyPlane(xw_display, LogoPM, xw_window, LogoGC, 0, 0,
  409.         Jewellogo_Width, Jewellogo_Height,
  410.         LOGO_LOC_X, LOGO_LOC_Y, 1L);
  411.  
  412.     XDrawImageString(xw_display, xw_window, VerGC, VER_LOC_X,
  413.         VER_LOC_Y+((VerFont->ascent)*3/2),
  414.         VerString, strlen(VerString));
  415.  
  416.     Redraw_Text();
  417.     Redraw_Game_Board();
  418.     XFlush(xw_display);
  419.     }
  420.  
  421. void Game_Timeout()
  422.     {
  423.     if (!Paused())
  424.         {
  425.         Logic_Timeout();
  426.         XFlush(xw_display);
  427.         }
  428.     if (JewelState==GAME)
  429.         { xw_set_timer(Get_Speed_ms()); }
  430.     }
  431.